package controller

import (
	"Graphite/model"
	"Graphite/service"
	"Graphite/util"
	"fmt"
	"github.com/gin-gonic/gin"
	"log"
	"net/http"
)

//修改配置表

func UpdateCon(c *gin.Context) {
	var pz model.PeiZhi
	if err := c.ShouldBind(&pz); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(pz); err == nil {
			col := "configuration"
			fmt.Println("-----", pz.Id)
			res := service.UpdateCon(pz, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//浸渍
//浸渍小时数据
func UpdateHourdata(c *gin.Context) {
	var dhd model.DippingHourData
	if err := c.ShouldBind(&dhd); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(dhd); err == nil {
			col := "dippinghourdata"
			fmt.Println("-----", dhd.Id)
			res := service.UpdateHour(dhd, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//天然气用量
func UpdateGas(c *gin.Context) {
	var ngu model.NaturalGasUsage
	if err := c.ShouldBind(&ngu); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(ngu); err == nil {
			col := "naturalgasusage"
			fmt.Println("-----", ngu.Id)
			res := service.UpdateGas(ngu, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//浸渍系统运行记录
func UpdateDipNote(c *gin.Context) {
	var dsn model.DippingSystemNote2
	if err := c.ShouldBind(&dsn); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(dsn); err == nil {
			col := "dippingsystemnote"
			fmt.Println("-----", dsn.Id)
			res := service.UpdateDipNote(dsn, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

func UpdateDipNote2(c *gin.Context) {
	var dsn model.DippingSystemNote
	if err := c.ShouldBind(&dsn); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(dsn); err == nil {
			col := "dippingsystemnote"
			fmt.Println("-----", dsn.Id)
			res := service.UpdateDipNote2(dsn, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}

}

//修改质量要求
func UpdateQua(c *gin.Context) {
	var qr model.QualityRequired
	if err := c.ShouldBind(&qr); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(qr); err == nil {
			col := "qualityrequired"
			fmt.Println("-----", qr.Id)
			res := service.UpdateQua(qr, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//装炉报告
func UpdateLoad(c *gin.Context) {
	var lo model.LoadOven
	if err := c.ShouldBind(&lo); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(lo); err == nil {
			col := "loadoven"
			fmt.Println("-----", lo.Id)
			res := service.UpdateLoad(lo, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//修改送电曲线
func UpdateEle(c *gin.Context) {
	var ec model.ElectricityCurve
	if err := c.ShouldBind(&ec); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(ec); err == nil {
			col := "electricitycurve"
			fmt.Println("-----", ec.Id)
			res := service.UpdateEle(ec, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//修改基本信息
func UpdateBasic(c *gin.Context) {
	var ba model.BasicInformation
	if err := c.ShouldBind(&ba); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(ba); err == nil {
			col := "basicinformation"
			fmt.Println("-----", ba.Id)
			res := service.UpdateBasic(ba, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//详细信息
func UpdateDetai(c *gin.Context) {
	var de model.DetailedInformation
	if err := c.ShouldBind(&de); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(de); err == nil {
			col := "detailedinformation"
			fmt.Println("-----", de.Id)
			res := service.UpdateDetail(de, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//成型1
//筛分记录
func UpdateScreening(c *gin.Context) {
	var sr model.ScreeningRecord
	if err := c.ShouldBind(&sr); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(sr); err == nil {
			col := "screeningrecord"
			fmt.Println("-----", sr.Id)
			res := service.UpdateScr(sr, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//成型2
//配料记录
func UpdateIngredient(c *gin.Context) {
	var ir model.IngredientRecord
	if err := c.ShouldBind(&ir); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(ir); err == nil {
			col := "ingredientrecord"
			fmt.Println("-----", ir.Id)
			res := service.UpdateIngred(ir, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//库管
//原始记录
func UpdateInitRecord(c *gin.Context) {
	var ir model.InitRecord
	if err := c.ShouldBind(&ir); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(ir); err == nil {
			col := "initrecord"
			fmt.Println("-----", ir.Id)
			res := service.UpdateInit(ir, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//质检
//检查日报
func UpdateDaily(c *gin.Context) {
	var dr model.DailyReport
	if err := c.ShouldBind(&dr); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(dr); err == nil {
			col := "dailyreport"
			fmt.Println("-----", dr.Id)
			res := service.UpdateDaily(dr, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//产品
//修改产品信息
func UpdateProduct(c *gin.Context) {
	var pro model.Production
	if err := c.ShouldBind(&pro); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(pro); err == nil {
			col := "production"
			fmt.Println("-----", pro.Id)
			res := service.UpdatePro(pro, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//隧道窑
//测点信息
func UpdateLocation(c *gin.Context) {
	var loc model.LocationInfo
	if err := c.ShouldBind(&loc); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(loc); err == nil {
			col := "locationinformation"
			fmt.Println("-----", loc.Id)
			res := service.UpdateLoc(loc, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//进车信息
func UpdateIncar(c *gin.Context) {
	var in model.Incar_Info
	if err := c.ShouldBind(&in); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(in); err == nil {
			col := "incar"
			fmt.Println("-----", in.Id)
			res := service.UpdateIncar(in, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//出车信息
func UpdateOutcar(c *gin.Context) {
	var out model.Outcar_Info
	if err := c.ShouldBind(&out); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(out); err == nil {
			col := "outcar"
			fmt.Println("-----", out.Id)
			res := service.UpdateOutcar(out, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//交接班
func UpdateHan_Suc(c *gin.Context) {
	var hs model.Handover_Successor
	if err := c.ShouldBind(&hs); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		if err := util.CheckData(hs); err == nil {
			col := "han_suc"
			fmt.Println("-----", hs.Id)
			res := service.UpdateHan_Suc(hs, col)
			util.Return(c, 200, util.SUCCESS, res)
		} else {
			fmt.Println("add err:")
			util.Return(c, 200, util.PARA_ERROR, err)
		}
	}
}

//删除

func Delete1(c *gin.Context) {

	id := c.Query("_id")
	fmt.Println("------", id)
	//col:="production"
	col := c.Query("collection")
	if col=="amount"{
		res := util.Delete2(c,id, col)
		util.Return(c, 200, util.SUCCESS, res)
	}else
	{
		res := util.Delete(id, col)
	util.Return(c, 200, util.SUCCESS, res)
	}
}

//平台参数

func PlatUpdate(c *gin.Context) {
	var plat model.PlatformParameters
	if err := c.Bind(&plat); err != nil {
		util.Return(c, 200, util.PARA_ERROR, err)
		return
	} else {
		util.UpdateOne(c, "platformparameters", plat, "_id", plat.Id)
	}
}
//货物管理 修改数量表同时修改对应重量表

func UpdateGoods(c *gin.Context){
	var num  model.Amount
	if err:= c.ShouldBind(&num); err!=nil{
		util.Return(c,200,util.PARA_ERROR,err)
		return
	}else {
		var data service.Data
		data = service.UpdateGoods(c,num,"amount")
		util.Return2(c,200,util.SUCCESS,data.UpdateAmount,data.UpdateWeight)
	}
}


func UploadImg(c *gin.Context) {
	file, header, err := c.Request.FormFile("file")
	if err != nil {
		log.Println("接收文件:",err)
		c.String(http.StatusBadRequest, fmt.Sprintf("file err : %s", err.Error()))
		return
	}
	service.UploadImg(c,file,header)
}